1
2
3
Næste
Fortryd en forpligtelse og gentag
$ git commit -m "Noget frygteligt vildledt" # (0: Din ulykke)
$ git reset HEAD ~ # (1)
<< rediger filer efter behov >> # (2)
$ git tilføj. # (3)
$ git commit -c ORIG_HEAD # (4)
Denne kommando er ansvarlig for fortrydelsen. Det fortryder din sidste forpligtelse, mens dit arbejdstræ (dine filers tilstand på disken) forbliver uberørt. Du bliver nødt til at tilføje dem igen, før du kan begå dem igen).
Foretag rettelser i arbejdende træfiler.
git tilføj alt, hvad du vil medtage i din nye forpligtelse.
Foretag ændringerne, og genbrug den gamle meddelelse. reset kopierede det gamle hoved til .git / ORIG_HEAD; commit med -c ORIG_HEAD åbner en editor, der oprindeligt indeholder logmeddelelsen fra den gamle commit og giver dig mulighed for at redigere den. Hvis du ikke har brug for at redigere beskeden, kan du bruge indstillingen -C.
Alternativt, for at redigere den foregående forpligtelse (eller bare dens meddelelse om forpligtelse), vil commit --amend tilføje ændringer inden for det aktuelle indeks til den tidligere forpligtelse.
For at fjerne (ikke tilbageføre) en forpligtelse, der er blevet skubbet til serveren, er det nødvendigt at omskrive historik med git push origin master --force.
Yderligere læsning
Hvordan kan jeg flytte HEAD tilbage til et tidligere sted? (Frittstående hoved) & Fortryd forpligter
Ovenstående svar viser dig git reflog, som du kan bruge til at bestemme SHA-1 til det tilsagn, du vil vende tilbage til. Når du har denne værdi, skal du bruge rækkefølgen af kommandoer som forklaret ovenfor.
HEAD ~ er det samme som HEAD ~ 1. Artiklen Hvad er HEAD in git? er nyttigt, hvis du ikke ønsker at forpligte flere forpligtelser.
|
Fortrydelse af en forpligtelse er lidt skræmmende, hvis du ikke ved, hvordan det fungerer. Men det er faktisk utrolig let, hvis du forstår det. Jeg viser dig de 4 forskellige måder, du kan fortryde en forpligtelse på.
mulighed 1: git reset - hårdt
Sig, at du har dette, hvor C er dit HEAD og (F) er tilstanden for dine filer.
(F)
A-B-C
↑
mestre
Du vil nuke begå C og aldrig se det igen og miste alle ændringer i lokalt modificerede filer. Du gør dette:
git reset - hårdt HOVED ~ 1
Resultatet er:
(F)
A-B
↑
mestre
Nu er B hovedet. Fordi du brugte --hard, nulstilles dine filer til deres tilstand ved commit B.
mulighed 2: git reset
Ah, men antag at begå C ikke var en katastrofe, men bare lidt væk. Du vil fortryde forpligtelsen, men hold dine ændringer til lidt redigering, inden du foretager en bedre forpligtelse. Start herfra med C som dit HOVED:
(F)
A-B-C
↑
mestre
Du kan gøre dette uden at --hard:
git reset HEAD ~ 1
I dette tilfælde er resultatet:
(F)
A-B-C
↑
mestre
I begge tilfælde er HEAD bare en indikator for den seneste forpligtelse. Når du foretager en git-nulstilling af HEAD ~ 1, beder du Git om at flytte HEAD-markøren tilbage en forpligtelse. Men (medmindre du bruger - hårdt), efterlader du dine filer, som de var. Så nu viser git-status de ændringer, du havde tjekket ind i C. Du har ikke mistet noget!
mulighed 3: git reset --soft
For den letteste berøring kan du endda fortryde din forpligtelse, men efterlade dine filer og dit indeks:
git reset - soft HEAD ~ 1
Dette efterlader ikke kun dine filer alene, det efterlader endda dit indeks alene. Når du udfører git-status, kan du se, at de samme filer er i indekset som før. Faktisk, lige efter denne kommando, kunne du git-begå, og du ville gøre om den samme forpligtelse, du lige havde.
mulighed 4: du git nulstillede - hårdt og har brug for at få den kode tilbage
En ting mere: Antag at du ødelægger en forpligtelse som i det første eksempel, men derefter opdager, at du trods alt havde brug for det? Hårdt held, ikke?
Nej, der er stadig en måde at få det tilbage. Indtast git reflog, og du vil se en liste over (delvis) commit shas (dvs. hashes), som du har flyttet rundt i. Find den commit, du ødelagde, og gør dette:
git checkout -b someNewBranchName shaYouDestroyed
Du har nu genoplivet den forpligtelse. Forpligtelser ødelægges faktisk ikke i Git i omkring 90 dage, så du kan normalt gå tilbage og redde en, som du ikke mente at slippe af med.
|
Der er to måder at "fortryde" din sidste forpligtelse, afhængigt af om du allerede har gjort din forpligtelse offentlig eller ej (skubbet til dit fjernlager):
Sådan fortrydes en lokal forpligtelse
Lad os sige, at jeg forpligtede mig lokalt, men nu vil jeg fjerne denne forpligtelse.
git log
begå 101: dårlig begå # Seneste begå. Dette ville blive kaldt 'HEAD'.
begå 100: god begå # Anden til sidste begå. Dette er den, vi ønsker.
For at gendanne alt tilbage, som det var før den sidste forpligtelse, er vi nødt til at nulstille til forpligtelsen før HEAD:
git reset --soft HEAD ^ # Brug --soft, hvis du vil beholde dine ændringer
git reset --hard HEAD ^ # Brug --hard, hvis du ikke er ligeglad med at beholde de ændringer, du har foretaget
Nu viser git log, at vores sidste forpligtelse er blevet fjernet.
Sådan fortrydes en offentlig forpligtelse
Hvis du allerede har gjort dine forpligtelser offentlige, vil du gerne oprette en ny forpligtelse, der vil "tilbageføre" de ændringer, du foretog i din tidligere forpligtelse (nuværende HEAD).
git vend tilbage HOVED
Dine ændringer vil nu blive tilbagekaldtog klar til at forpligte dig:
git commit -m 'gendannelse af den fil, jeg fjernede ved et uheld'
git log
begå 102: gendannelse af filen, som jeg ved et uheld fjernede
begå 101: fjerne en fil, som vi ikke har brug for
begå 100: tilføj en fil, som vi har brug for
For mere information, se Git Basics - Undoing Things.
|
Tilføj / fjern filer for at få tingene som du vil:
git rm classdir
git tilføj sourcedir
Derefter ændres forpligtelsen:
git commit --ændre
Den forrige, fejlagtige forpligtelse redigeres for at afspejle den nye indekstilstand - med andre ord, det vil være som om du aldrig gjorde fejlen i første omgang.
Bemærk, at du kun skal gøre dette, hvis du ikke har skubbet endnu. Hvis du har skubbet, bliver du bare nødt til at foretage en løsning normalt.
|
git rm yourfiles / *. klasse
git commit -a -m "slettede alle klassefiler i mappen 'yourfiles'"
eller
git reset - hårdt HOVED ~ 1
Advarsel: Ovenstående kommando fjerner permanent ændringerne af .java-filerne (og andre filer), som du ønskede at begå.
Den hårde nulstilling til HEAD-1 indstiller din arbejdskopi til tilstanden for forpligtelsen før din forkerte forpligtelse.
|
At ændre den sidste forpligtelse
Erstat filerne i indekset:
git rm --cached * .klasse
git add * .java
Derefter, hvis det er en privat filial, skal du ændre forpligtelsen:
git commit --ændre
Eller, hvis det er en delt filial, skal du foretage en ny forpligtelse:
git commit -m 'Erstat .class-filer med .java-filer'
(For at ændre en tidligere forpligtelse skal du bruge den fantastiske interaktive rebase.)
ProTip ™: Føj * .klasse til en gitignore for at stoppe dette igen.
At tilbageføre en forpligtelse
Ændring af en forpligtelse er den ideelle løsning, hvis du har brug for at ændre den sidste forpligtelse, men en mere generel løsning nulstilles.
Du kan nulstille Git til enhver forpligtelse med:
git reset @ ~ N
Hvor N er antallet af begivenheder før HEAD, og @ ~ nulstilles til den tidligere forpligtelse.
Så i stedet for at ændre forpligtelsen kan du bruge:
git reset @ ~
git add * .java
git commit -m "Tilføj .java-filer"
Tjek git help reset, specifikt afsnittene om --soft - blandet og - hårdt for en bedre forståelse af, hvad dette gør.
Reflog
Hvis du ødelægger, kan du altid bruge reflogen til at finde droppede forpligtelser:
$ git reset @ ~
$ git reflog
c4f708b HEAD @ {0}: reset: flytter til @ ~
2c52489 HEAD @ {1}: commit: tilføjede nogle .class-filer
$ git nulstil 2c52489
... og du er tilbage, hvor du startede
|
Brug git revert .
For at få commit-id'et skal du bare bruge git log.
|
Hvis du planlægger at fortryde en lokal forpligtelse helt, uanset hvad du ændrer, gjorde du på forpligtelsen, og hvis du ikke bekymrer dig om noget, skal du bare gøre følgende kommando.
git reset - hårdt HOVED ^ 1
(Denne kommando ignorerer hele din forpligtelse, og dine ændringer går helt tabt fra dit lokale arbejdstræ). Hvis du vil fortryde din forpligtelse, men du vil have dine ændringer i iscenesættelsesområdet (før begå ligesom efter git tilføj), skal du gøre følgende kommando.
git reset - soft HEAD ^ 1
Nu kommer dine forpligtede filer ind i iscenesættelsesområdet. Antag, at hvis du vil opscore filerne, fordi du skal redigere noget forkert indhold, skal du gøre følgende kommando
git reset HEAD
Nu forpligtede filer til at komme fra det iscenesatte område til det ikke-iscenesatte område. Nu er filer klar til redigering, så uanset hvad du ændrer, vil du gå redigere og tilføje det og foretage en ny / ny forpligtelse.
Mere (link brudt) (Arkiveret version)
|
Hvis du har installeret Git Extras, kan du køre git undo for at fortryde den seneste forpligtelse. git fortryd 3 fortryder de sidste tre forpligtelser.
|
Jeg ønskede at fortryde de seneste fem forpligtelser i vores delte arkiv. Jeg slog op på den revisions-id, som jeg ønskede at returnere til. Så skrev jeg det følgende.
prompt> git reset --hard 5a7404742c85
HEAD er nu på 5a74047 Tilføjet endnu en side til kataloget
prompt> git push origin master --force
I alt 0 (delta 0), genbrugt 0 (delta 0)
fjernbetjening: bb / acl: neoneye er tilladt. accepteret nyttelast.
Til git@bitbucket.org: thecompany / prometheus.git
+ 09a6480 ... 5a74047 master -> master (tvungen opdatering)
prompt>
|
Jeg foretrækker at bruge git rebase -i til dette job, fordi en god liste dukker op, hvor jeg kan vælge de forpligtelser, jeg vil slippe af med. Det er måske ikke så direkte som nogle andre svar her, men det føles bare rigtigt.
Vælg hvor mange forpligtelser du vil liste, og påkald derefter denne (for at hente de sidste tre)
git rebase -i HEAD ~ 3
Prøve liste
vælg aa28ba7 Sanity check for RtmpSrv port
vælg c26c541 RtmpSrv-version
vælg 58d6909 Bedre URL-dekodningsunderstøttelse
Derefter fjerner Git forpligtelser for enhver linje, du fjerner.
|
Sådan løses den tidligere lokale forpligtelse
Brug git-gui (eller lignende) til at udføre en git-forpligtelse --amend. Fra GUI kan du tilføje eller fjerne individuelle filer fra forpligtelsen. Du kan også ændre forpligtelsesmeddelelsen.
Sådan fortrydes den tidligere lokale forpligtelse
Nulstil bare din filial til den forrige placering (for eksempel ved hjælp af gitk eller git rebase). Anvend derefter dine ændringer igen fra en gemt kopi. Efter affaldsindsamling i dit lokale arkiv vil det være som om den uønskede forpligtelse aldrig skete. For at gøre alt dette i en enkelt kommando skal du bruge git reset HEAD ~ 1.
Ordaf advarsel: Uforsigtig brug af git reset er en god måde at få din arbejdskopi i en forvirrende tilstand. Jeg anbefaler, at Git-nybegyndere undgår dette, hvis de kan.
Sådan fortrydes en offentlig forpligtelse
Udfør en omvendt kirsebærpluk (git-revert) for at fortryde ændringerne.
Hvis du endnu ikke har trukket andre ændringer til din gren, kan du bare gøre ...
git revert - ikke rediger HEAD
Skub derefter din opdaterede filial til det delte lager.
Forpligtelseshistorikken viser begge forpligtelser separat.
Avanceret: Korrektion af den private filial i det offentlige arkiv
Dette kan være farligt - sørg for at du har en lokal kopi af filialen, der skal genudskrives.
Bemærk også: Du vil ikke gøre dette, hvis en anden muligvis arbejder på filialen.
git push --delete (branch_name) ## fjern offentlig version af filialen
Rydd din filial lokalt, og tryk derefter igen ...
git push-oprindelse (filialnavn)
I det normale tilfælde behøver du sandsynligvis ikke bekymre dig om, at din private filialforpligtelseshistorie er uberørt. Skub bare en opfølgningsforpligtelse (se 'Sådan fortrydes en offentlig forpligtelse' ovenfor), og lav derefter en squash-fusion for at skjule historien.
|
Hvis du vil fortryde det permanent, og du har klonet et lager
Forpligtelses-id'et kan ses af
git log
Så kan du gøre -
git reset --hard
git push-oprindelse -f
|
Hvis du har begået uønsket, men ikke skubbet,
git reset - soft HEAD ~ 1
HEAD ~ 1 er en stenografi for begivenheden foran hovedet. Alternativt kan du henvise til SHA-1 for hashen, hvis du vil nulstille til. --soft option sletter forpligtelsen, men den efterlader alle dine ændrede filer "Ændringer der skal begås", som git-status ville sige det.
Hvis du vil slippe af med ændringer i sporede filer i arbejdstræet siden begåelsen før hoved brug "--hard" i stedet.
ELLER
Hvis du allerede har skubbet og nogen trukket, hvilket normalt er min sag, kan du ikke bruge git reset. Du kan dog lave en git-tilbagevenden,
git vend tilbage HOVED
Dette vil skabe en ny forpligtelse, der vender alt introduceret ved et utilsigtet begå.
|
På SourceTree (GUI til GitHub) kan du højreklikke på commit og foretage en 'Reverse Commit'. Dette skulle fortryde dine ændringer.
På terminalen:
Du kan alternativt bruge:
git vende tilbage
Eller:
git reset --soft HEAD ^ # Brug --soft, hvis du vil beholde dine ændringer.
git reset --hard HEAD ^ # Brug --hard hvis du ikke er ligeglad med at beholde dine ændringer.
|
En enkelt kommando:
git reset --soft 'HEAD ^'
Det fungerer godt at fortryde den sidste lokale forpligtelse!
|
Nulstil det bare ved hjælp af kommandoen nedenfor ved hjælp af git:
git reset - soft HEAD ~ 1
Forklar: hvad git-nulstilling gør, nulstilles det stort set til enhver forpligtelse, du gerne vil vende tilbage til, så hvis du kombinerer det med --soft-nøgle, vil det gå tilbage, men hold ændringerne i din fil (er), så du kommer tilbage til det stadium, hvor filen netop blev tilføjet, HEAD er leder af filialen, og hvis du kombinerer med ~ 1 (i dette tilfælde bruger du også HEAD ^), vil den kun gå tilbage én forpligtelse, hvad du vil have. ..
Jeg opretter trinene i billedet nedenfor i flere detaljer for dig, herunder alle trin, der kan ske i virkelige situationer og begå koden:
|
Hvordan fortryder man den sidste Git-forpligtelse?
For at gendanne alt tilbage, som det var før den sidste forpligtelse, er vi nødt til at nulstille til forpligtelsen før HEAD.
Hvis du ikke vil beholde dine ændringer, som du har foretaget:
git reset - hårdt HOVED ^
Hvis du vil beholde dine ændringer:
git reset - soft HEAD ^
Tjek nu din git-log. Det vil vise, at vores sidste forpligtelse er blevet fjernet.
|
"Nulstil arbejdstræet til sidste forpligtelse"
git reset - hårdt HOVED ^
"Rens ukendte filer fra arbejdstræet"
git ren
se - Git Quick Reference
BEMÆRK: Denne kommando sletter din tidligere forpligtelse, så brug forsigtigt! git reset - hårdt er mere sikkert.
|
Brug reflog for at finde en korrekt tilstand
git reflog
REFLOG FØR NULSTILLING
Vælg den rigtige reflog (f3cb6e2 i mit tilfælde) og skriv
git reset --hard f3cb6e2
Derefter nulstilles repo HEAD til det HEADid
LOG EFTER NULSTILLING
Endelig ser reflog ud som billedet nedenfor
REFLOG FINAL
|
Første løb:
git reflog
Det viser dig alle de mulige handlinger, du har udført på dit arkiv, for eksempel, begå, flet, træk osv.
Gør derefter:
git reset --hard ActionIdFromRefLog
|
Fortryd sidste forpligtelse:
git reset --soft HEAD ^ eller git reset --soft HEAD ~
Dette fortryder den sidste forpligtelse.
Her betyder --soft nulstilles til iscenesættelse.
HEAD ~ eller HEAD ^ betyder at flytte til at begå sig før HEAD.
Erstat sidste forpligtelse til ny forpligtelse:
git commit --ændring -m "besked"
Det erstatter den sidste forpligtelse med den nye forpligtelse.
|
Anden måde:
Tjek den gren, du vil vende tilbage, og nulstil derefter din lokale arbejdskopi til den forpligtelse, som du vil være den seneste på fjernserveren (alt efter det går farvel). For at gøre dette højreklikkede jeg i SourceTree på og valgte "Nulstil BRANCHNAME til denne forpligtelse".
Naviger derefter til dit arkivs lokale bibliotek og kør denne kommando:
git -c diff.mnemonicprefix = false -c core.quotepath = false push -v -f --tags REPOSITORY_NAMEBRANCHNAME: BRANCHNAME
Dette sletter alle forpligtelser efter den aktuelle i dit lokale arkiv, men kun for den ene gren.
|
Skriv git log og find den sidste kommission hash-kode, og indtast derefter:
git reset
|
I mit tilfælde begik jeg ved et uheld nogle filer, som jeg ikke ønskede. Så jeg gjorde følgende, og det fungerede:
git reset - soft HEAD ^
git rm --cached [filer, du ikke har brug for]
git add [filer du har brug for]
git commit -c ORIG_HEAD
Bekræft resultaterne med gitk eller git log --stat
|
Enkelt, kør dette på din kommandolinje:
git reset - soft HEAD ~
|
Der er to hovedscenarier
Du har ikke skubbet forpligtelsen endnu
Hvis problemet var ekstra filer, du bestilte (og du ikke vil have dem i arkivet), kan du fjerne dem ved hjælp af git rm og derefter forpligte sig til --amend
git rm
Du kan også fjerne hele mapper med -r eller endda kombinere med andre Bash-kommandoer
git rm -r
git rm $ (find -navn '* .class')
Når du har fjernet filerne, kan du forpligte dig med --amend-indstillingen
git commit --amend -C HEAD # indstillingen -C er at bruge den samme commit-besked
Dette vil omskrive din nylige lokale forpligtelse ved at fjerne de ekstra filer, så disse filer vil aldrig blive sendt på push og vil også blive fjernet fra dit lokale .git-arkiv af GC.
Du har allerede skubbet forpligtelsen
Du kan anvende den samme løsning i det andet scenarie og derefter lave git push med -f-indstillingen, men det anbefales ikke, da det overskriver fjernhistorikken med en divergerende ændring (det kan ødelægge dit lager).
I stedet skal du udføre forpligtelsen uden --ændring (husk dette om -ændring ": Denne mulighed omskriver historien ved den sidste begivenhed).
|
For en lokal forpligtelse
git reset - soft HEAD ~ 1
eller hvis du ikke husker nøjagtigt, i hvilken forpligtelse det er, kan du bruge det
git rm --cached
For en presset begåelse
Den rigtige måde at fjerne filer fra lagerhistorikken på er at bruge git filter-gren. Det er,
git filter-branch --index-filter 'git rm --cached ' HEAD
Men jeg anbefaler, at du bruger denne kommando med omhu. Læs mere på git-filter-branch (1) Manual Page.
|
For at nulstille til den forrige revision skal du slette alle uforpligtede ændringer permanent:
git reset - hårdt HOVED ~ 1
|
HVAD SKAL DU BRUGE, nulstil --soft eller reset --hard?
Jeg tilføjer bare to cent til @ Kyralessas svar:
Hvis du er usikker på, hvad du skal bruge, gå til --soft (jeg brugte denne konvention til at huske det - soft for safe).
Hvorfor ?
Hvis du vælger - hårdt ved en fejltagelse, mister du dine ændringer, som det ikke var før.
Hvis du vælger --soft ved en fejltagelse, kan du opnå de samme resultater af --hard ved at anvende yderligere kommandoer
git nulstil HEAD-fil.html
git checkout - file.html
Fuldt eksempel
ekko "nogle ændringer ..."> file.html
git tilføj fil.html
git begå -m "forkert begå"
# Jeg skal nulstille
git reset - hård HEAD ~ 1 (annuller ændringer)
# ELLER
git reset --soft HEAD ~ 1 # Tilbage til iscenesættelse
git nulstil HEAD file.html # tilbage til arbejdskataloget
git checkout - file.html # annuller ændringer
Kreditter går til @Kyralessa.
|
1
2
3
Næste
Meget aktivt spørgsmål. Optjen 10 omdømme for at besvare dette spørgsmål. Omdømmekravet hjælper med at beskytte dette spørgsmål mod spam og ikke-svar-aktivitet.
Er det ikke det svar, du leder efter? Gennemse andre spørgsmål mærket git version-control git-commit fortryd eller stil dit eget spørgsmål.